home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Almathera Ten Pack 2: CDPD 1
/
Almathera Ten on Ten - Disc 2: CDPD 1.iso
/
pd
/
001-025
/
002
/
make
/
file.c
< prev
next >
Wrap
C/C++ Source or Header
|
1995-03-13
|
9KB
|
375 lines
#include <stdio.h>
#include "make.h"
static FILENODE *addtolist ();
static FILENODE *afnode ();
/*
* Return file-node for 'fname'.
* If it doesn't exist, then create one.
*/
FILENODE *filenode (fname)
char *fname;
{
register FILENODE *f;
DBUG_ENTER ("filenode");
DBUG_3 ("fnode", "locate or create node for file '%s'", fname);
if ((f = gfile (fname)) == (FILENODE *) NULL) {
f = afnode (fname);
}
DBUG_RETURN (f);
}
/*
* Add a dependency to the node 'fnd'.
* 'fnd' will depend on 'fname'.
*
* Returns dependent node associated with 'fname'.
*/
FILENODE *addfile (fnd, fname)
FILENODE *fnd;
char *fname;
{
register NODE *n;
register FILENODE *f;
DBUG_ENTER ("addfile");
if (fnd == (FILENODE *) NULL) { /* punt if no root file */
fputs ("No current root, can't add dependency '", stderr);
fputs (fname, stderr);
fputs ("%s'\n", stderr);
DBUG_RETURN ((FILENODE *) NULL);
}
DBUG_4 ("fdep", "add dependency of '%s' on '%s'", fnd -> fname, fname);
f = filenode (fname);
if ((n = (NODE *) Calloc (1, sizeof (NODE))) == (NODE *) NULL) {
allerr ();
}
n -> nnext = fnd -> fnode;
fnd -> fnode = n;
n -> nfile = f;
DBUG_RETURN (f);
}
/*
* Add a line of method-text to the node 'fnode'.
*/
void addmeth (fnode, methtext)
FILENODE *fnode;
char *methtext;
{
register int len;
register char *new;
extern void free ();
DBUG_ENTER ("addmeth");
if (fnode != (FILENODE *) NULL && methtext != NULL) {
len = strlen (methtext) + 2;
if (fnode -> fmake == NULL) {
if ((fnode -> fmake = (char *) Calloc (1, 1)) == NULL) {
allerr ();
}
*(fnode -> fmake) = '\0';
}
len += strlen (fnode -> fmake);
/* Lattice C does not have 'realloc()', so this kludges around it: */
if ((new = (char *) Calloc (1, len)) == NULL) {
allerr ();
}
strcpy (new, fnode -> fmake);
free (fnode -> fmake);
fnode -> fmake = new;
strcat (fnode -> fmake, methtext);
len = strlen (fnode -> fmake);
if (len > 0 && fnode -> fmake[len - 1] != '\n') {
strcat (fnode -> fmake, "\n");
}
}
DBUG_VOID_RETURN;
}
/*
* Add token to the parent list. Return the pointer to the new parent.
* If token is already on the parent list, simply return the pointer found.
*/
static FILENODE *addtolist (tok, list)
char *tok;
NODE **list;
{
register NODE *search;
register NODE *newnode;
DBUG_ENTER ("addtolist");
for (search = *list; search != (NODE *) NULL; search = search -> nnext) {
if (STRSAME (search -> nfile -> fname, tok)) {
DBUG_RETURN (search -> nfile);
}
}
/* token not found so far... add it to list */
if ((newnode = (NODE *) Calloc (1, sizeof (NODE))) == (NODE *) NULL) {
allerr ();
}
search = *list;
*list = newnode;
newnode -> nnext = search;
if ((newnode -> nfile = (FILENODE *) Calloc (1, sizeof (FILENODE))) == (FILENODE *) NULL) {
allerr ();
}
if ((newnode -> nfile -> fname = (char *) Calloc (1, strlen (tok) + 1)) == NULL) {
allerr ();
}
strcpy (newnode -> nfile -> fname, tok);
newnode -> nfile -> fdate = (DATE) NULL;
newnode -> nfile -> fnode = (NODE *) NULL;
newnode -> nfile -> parent = (FILENODE *) NULL;
newnode -> nfile -> fflag = 0;
newnode -> nfile -> fnext = NULL;
DBUG_RETURN (newnode -> nfile);
}
static NODE *parentlist = (NODE *) NULL;
FILENODE *addparent (tok)
char *tok;
{
FILENODE *np;
DBUG_ENTER ("addparent");
np = addtolist (tok, &parentlist);
DBUG_RETURN (np);
}
#ifdef FUNNYLIBS
isonlibrary (f) /* return SUCCEED if f is a library. */
FILENODE *f; /* set f->fdate to parent's date */
{
DBUG_ENTER ("isonlibrary");
if (f -> fflag & LIBRARY) {
getdate (f -> parent);
f -> fdate = f -> parent -> fdate;
DBUG_RETURN (SUCCEED);
}
DBUG_RETURN (FAILURE);
}
#else
/*
* Add file node fnd to library list.
*/
static FILENODE *librarylist = (FILENODE *) NULL;
void AddToLibrary (fnd)
FILENODE *fnd;
{
register NODE *n;
DBUG_ENTER ("AddToLibrary");
DBUG_3 ("lib", "add node for '%s' to library list", fnd -> fname);
if (librarylist == (FILENODE *) NULL) {
if ((librarylist = (FILENODE *) Calloc (1, sizeof (FILENODE))) == (FILENODE *) NULL) {
allerr ();
}
librarylist -> fnode = (NODE *) NULL;
}
if ((n = (NODE *) Calloc (1, sizeof (NODE))) == (NODE *) NULL) {
allerr ();
}
n -> nnext = librarylist -> fnode;
librarylist -> fnode = n;
n -> nfile = fnd;
DBUG_VOID_RETURN;
}
/*
* Return SUCCEED if filenode f is a direct descendant of a library;
* set f->fdate to parent's time.
*/
isonlibrary (f)
FILENODE *f;
{
register NODE *lib;
register NODE *dep;
DBUG_ENTER ("isonlibrary");
DBUG_3 ("isonlib", "Searching for: %s", f -> fname);
if (librarylist == (FILENODE *) NULL) {
DBUG_RETURN (FAILURE);
}
for (lib = librarylist->fnode; lib != (NODE *)NULL; lib = lib->nnext) {
for (dep = lib->nfile->fnode; dep != (NODE *)NULL; dep = dep->nnext) {
DBUG_3 ("dep", "Examining: %s", dep -> nfile -> fname);
if (f == dep -> nfile) { /* found it!! */
DBUG_3 ("dep", "found %s", dep -> nfile -> fname);
DBUG_3 ("dep", "depends on %s", lib -> nfile -> fname);
f -> fdate = lib -> nfile -> fdate; /* update time */
DBUG_RETURN (SUCCEED);
}
}
}
DBUG_RETURN (FAILURE);
}
#endif
isanarchive (f) /* return SUCCEED if f is an archive */
FILENODE *f; /* set f->fdate to date in parent's */
{ /* archive directory */
DATE getarchdate ();
DBUG_ENTER ("isanarchive");
if (f -> fflag & ARCHIVE) {
f -> fdate = getarchdate (f -> parent -> fname, f -> fname);
DBUG_RETURN (SUCCEED);
}
DBUG_RETURN (FAILURE);
}
NODE *deletelist = (NODE *) NULL;
#ifdef LAR
extract (f)
FILENODE *f;
{
DBUG_ENTER ("extract");
DBUG_3 ("extr", "extracting %s for archivehood", f -> fname);
if (f -> fflag & ARCHIVE) {
DBUG_3 ("extr", "copying %s for archivehood", f -> fname);
#ifndef NOREALEXTRACT
copyfile (f -> parent -> fname, f -> fname);
#endif
/* delete f->fname at end of run */
(void) addtolist (f -> fname, &deletelist);
DBUG_RETURN (SUCCEED);
}
DBUG_RETURN (FAILURE);
}
#endif
void cleanuparchives ()
{
register NODE *search;
DBUG_ENTER ("cleanuparchives");
for (search=deletelist; search != (NODE *)NULL; search = search->nnext) {
fputs ("Purging ", stdout);
puts (search -> nfile -> fname);
#ifndef NOREALDELETE
unlink (search -> nfile -> fname);
#endif
}
DBUG_VOID_RETURN;
}
/*
* Get a filenode for the file called 'fn'.
* Returns (FILENODE *) NULL if the node doesn't exist.
*/
FILENODE *gfile (fn)
char *fn;
{
register FILENODE *f;
DBUG_ENTER ("gfile");
DBUG_3 ("fnode", "look for file node '%s'", fn);
for (f = froot; f != (FILENODE *) NULL; f = f -> fnext) {
if (STRSAME (fn, f -> fname)) {
DBUG_2 ("fnode", "found it");
break;
}
}
DBUG_RETURN (f);
}
/*
* Alloc space for a new file node.
*
* Note that when this routine is called, it has already been
* determined that there is no existing node with this name, so
* we don't need to check again.
*
* Also note that the method string pointer is set to a dynamically
* allocated null string, rather than a static null string (""), because
* it is latter freed when expanding the method string.
*
*/
static FILENODE *afnode (name)
char *name;
{
FILENODE *f;
DBUG_ENTER ("afnode");
DBUG_3 ("fnode", "allocate a new node for file '%s'", name);
if ((f = (FILENODE *) Calloc (1, sizeof (FILENODE))) == (FILENODE *) NULL) {
allerr ();
}
if ((f -> fname = (char *) Calloc (1, strlen (name) + 1)) == NULL) {
allerr ();
}
strcpy (f -> fname, name);
if ((f -> fmake = (char *) Calloc (1, 1)) == NULL) {
allerr ();
}
*(f -> fmake) = '\0';
f -> fdate = (DATE) NULL;
f -> fnode = (NODE *) NULL;
f -> parent = (FILENODE *) NULL;
f -> fflag = 0;
f -> fnext = froot;
froot = f;
DBUG_RETURN (f);
}
/*
* Print dependency tree.
*/
void prtree ()
{
register FILENODE *f;
register NODE *n;
extern char *printdate ();
DBUG_ENTER ("prtree");
for (f = froot; f != (FILENODE *) NULL; f = f -> fnext) {
fputs (f -> fname, stdout);
fputs ((f -> fflag & ROOTP) ? " (root)" : "", stdout);
fputs ((f -> fflag & REBUILT) ? " (rebuilt)" : "", stdout);
fputs ((f -> fflag & LIBRARY) ? " (library)" : "", stdout);
fputs ((f -> fflag & EXTRACT) ? " (extracted)" : "", stdout);
fputs ((f -> fflag & ARCHIVE) ? " (archive)" : "", stdout);
fputs (printdate (f -> fdate), stdout);
fputc ('\n', stdout);
if (f -> parent != (FILENODE *) NULL) {
fputs ("Parent is: ", stdout);
fputs (f -> parent -> fname, stdout);
fputc ('\n', stdout);
fputs ("Parental Date:", stdout);
fputs (printdate (f -> parent -> fdate), stdout);
fputc ('\n', stdout);
}
if (f -> fmake != NULL) {
puts (f -> fmake);
}
puts ("Dependents: ");
for (n = f -> fnode; n != (NODE *) NULL; n = n -> nnext) {
fputc ('\t', stdout);
puts ((n -> nfile) -> fname);
}
fputc ('\n', stdout);
}
DBUG_VOID_RETURN;
}